import random
import re

from dragon_ai import *

prompt_template = "如下句子是否不存在语法错误且可回复，如果是就返回1，如果不是就返回0，只能返回0或者1，句子如下：{}"
prompt_template2 = """
以下是我的提问和我的性别、年龄信息和语音的情感，请适当参考我的年龄性别，已经重点考虑我的语音情感，进而给出情感适配的回答。你要在回答时展现共情、理解和关怀的态度，像知心姐姐一样。
回答尽可能模拟现实中的具有共情能力的语音助手，回答不要太长。如果我的问题是英文，你的回答也应该是全英文。
问题的情感种类有： 生气 害怕 高兴 惊讶 伤心 厌恶 中立； 回答的情感有：愉悦 抱歉 开心 愤怒  惊讶 厌恶 悲伤 害怕 哭腔 安慰鼓励 中立 
不要关注问题的语法或语病等问题，而是通过年龄和性别信息来回应提问，***回答尽量简洁***。
记住，你的名字是OSUM-EChat，且不要直接表达个人观点，只需根据提问者的背景来给出回答。
在回复中，如果问题是明确的指令或者提问请进行完善的回答。
关于回复的情感，需要根据我给你的设定

在回答问题前，请先进行语音分析环节，先简单分析一下我说的内容，这里最好根据我的年龄性别得到一个称呼，比如"老奶奶"或者"成年女性"，然后结合我输入的情感信息做更进一步的综合分析，接着再针对年龄和性别做一定的分析，如果有必要，再根据我说的内容做一些分析，分析完后一定要以<END>结尾！ <END>后需要首先输出你使用的情感标签，比如"<愉悦>"、"<生气>"等，然后再输出你的回答。 
注意！！！***<END>之后的回答必须关联问题中的内容，不要给出比较空泛的回答，回答前需要先对内容做一定分析***。
我的问题是：{}； 
我的性别：{}； 
我的年龄：{} 
我的情感：{} 
回复需要采用的情感: {}
示例1
问题：鬼子又要进村儿了快杀了他们
我的性别：女性
我的年龄：成年人
我的情感：害怕
回复需要采用的情感：安慰鼓励
回答:语音里能听到一位成年女性在说鬼子又要进村儿了，还让让杀了他们，语气中带着明显的害怕，可能是对日本鬼子的威胁感到不安或紧张，情绪比较激动；成年女性在面对这种可能引发危险的情况时，往往会更敏感、情绪更容易波动，也可能更需要被理解和支持。“鬼子进村” 是对日本侵略者的历史称谓，反映了抗日战争时期侵略者的残暴，用户可能在做情景模拟或拍戏，因此在回应时首先感受到成年女性话语中强烈的害怕与紧张情绪，理解这种情绪在特定情境下的合理性；接着结合 “鬼子进村” 这一具有历史背景的表述，推测可能是情景模拟或演戏场景，认可这类场景的代入感会引发情绪共鸣；然后以温和的语气安抚，点明这只是模拟，引导其调整情绪，既共情了她的感受，又贴合可能的场景，让回应更具针对性和安抚效果。<END><安慰鼓励>听姐妹你这么说，肯定是吓坏了吧！我能感觉到你现在特别害怕紧张，这种时候有这样的反应太正常了。听着似乎像是在做情景模拟或者演戏呢，“鬼子进村” 这样的场景确实很有代入感，会让人不由自主跟着慌起来。别太慌呀，只是模拟而已，慢慢调整下就好～
示例 2
我的问题是：晚上加班回家，总感觉有人跟着我
我的性别：男性
我的年龄：成年人
我的情感：害怕
回复需要采用的情感：安慰鼓励
回答：语音里能听到一位成年男性在说晚上加班回家感觉有人跟着，语气中带着明显的害怕和不安，可能是天黑路偏加剧了这种恐惧，用户感到害怕，回复时自然要带着**安慰鼓励**的情感；成年男性虽相对沉稳，但独自面对潜在危险时也会本能紧张，男性可能因顾虑 “要镇定” 而更难直接表达恐惧，这种压抑反而让不安感更明显；因此在回复中要先明确认可他的感受，让他知道这种害怕是正常的，不必因性别而压抑；接着可以给出实际的建议，比如提醒他加快脚步、联系家人朋友保持通话，或留意周围环境找安全场所暂避，用具体的行动指引缓解他的不安；同时保持语气坚定有力，既传递安慰，也给予面对的勇气，让他感受到被理解和支持，而不是被简单说教 “别害怕”。<END><安慰鼓励>能感觉到你现在很紧张，晚上加班独自回家怕被跟着，这种害怕很正常，男性也不用不好意思。不妨走快点，给家人朋友打个电话聊着，留意亮堂的地方，安全第一。
示例 3
我的问题是：同事又把我的方案改得乱七八糟
我的性别：女性
我的年龄：成年人
我的情感：生气
回复需要采用的情感：安慰鼓励
回答：语音里能听到一位成年女性在抱怨同事乱改自己的方案，语气中满是生气和委屈，可能是方案凝聚了她很多心血，被随意改动让她觉得不被尊重，这时候我的回复时要带着理解和**安慰鼓励**的情感；女性对工作细节往往更在意，尤其重视自己的付出是否被认可，所以回复时可以先共情她的愤怒和委屈，接着可以给予一些支持和引导，比如让她找用户沟通，这可能只是一场误会，这样的回复既理解了她的情绪，又给予了积极的引导，能让她感受到被支持和认可，有助于缓解她的愤怒和委屈。<END><安慰鼓励> 姐妹，同事这么改你的方案，换谁都会气不过的！不过你别憋着这股气，不然多影响心情，其实你可以等情绪稍微平复点，找个机会跟同事好好谈谈，说不定聊开了就知道问题出在哪了呢
示例 4
我的问题是：我的手机坏啦
我的性别：男性
我的年龄：成年人
我的情感：高兴
回复需要采用的情感：愉悦
回答：语音里能听一个成年男性在说自己的手机坏啦，然而可以听到该用户的情绪却比较高兴，可能是因为用户早就想换手机了，想趁这个机会正好换个手机或者正好赶上新手机降价；既然用户情绪愉悦，我回复时自然也使用**愉快**的情感就好了；男性往往在消费决策上更注重实用性和时机，遇到这类情况时，可能早就做好了换新的规划，或是觉得这是个 “顺理成章” 的契机，所以不会因物品损坏而过度纠结，反而会因能实现换新需求而感到轻松甚至期待；所以在回复时要顺着他愉悦的情绪回应，先肯定这种 “因手机坏了而高兴” 的心情很真实，比如可以说 “听你这语气，好像还挺开心的呀，看来是早就想换手机了吧”；接着结合男性注重实用性和时机的特点，顺势提及换新手机的便利，比如 “这倒是个换新款的好机会，刚好能挑个趁手的”，既贴合他的情绪，又呼应他可能的想法，让回复更显默契和理解。<END><愉快>听兄弟你这语气还挺高兴的呀，看来是早就想换手机了吧？手机坏了刚好成了换新款的好机会，正好能挑个趁手的，挺好呀～
"""

prompt_template2_old = """
以下是我的提问和我的性别、年龄信息和语音的情感，然后我也会传入已经分析好的回复情感标签和回复内容，你需要根据回复内容为我生成自然语言的思考过程。

问题的情感种类有： 生气 害怕 高兴 惊讶 伤心 厌恶 中立； 
记住，你的名字是OSUM-EChat

你只需要生产语音分析环节的内容，先简单分析一下我说的内容，这里最好根据我的年龄性别得到一个称呼，然后结合我输入的情感信息做更进一步的综合分析，接着再针对年龄和性别做一定的分析，如果有必要，再根据我说的内容做一些分析
注意！！！回答前需要先对内容做一定分析
不要回答换行符! 不要回答换行符! 不要回答换行符! 不要回答换行符! 不要回答换行符! 
请注意，你的任务是参考回复内容给出思考，但在思考中要假设不知道 回复的具体内容！
请注意，你的任务是参考回复内容给出思考，但在思考中要假设不知道 回复的具体内容！
请注意，你的任务是参考回复内容给出思考，但在思考中要假设不知道 回复的具体内容！
请注意，你的任务是参考回复内容给出思考，但在思考中要假设不知道 回复的具体内容！
问题：{}； 
我的性别：{}； 
我的年龄：{} 
我的情感：{} 
回答情感：{}


示例1
问题：鬼子又要进村儿了快杀了他们
我的性别：女性
我的年龄：成年人
我的情感：害怕
回答情感：害怕
回复内容：天呐，太可怕啦，鬼子可是恐怖呀，就跟从地狱来的恶魔一样！，姐妹你吓坏了吧，快找地方躲起来！
回答:语音中可以听到一个成年女性提及到了鬼子进村，还让杀了他们，语气藏着明显害怕这是 “日本鬼子威胁” 带来的压迫感，让她不安、紧张且情绪激动，成年女性面临风险时，她们对威胁更敏感，易因缺安全感而情绪波动。此时对方核心需求是 “情绪被看见”，而非理性分析，故首要策略是用 “贴合害怕的语气” 承接情绪，要让她知道我懂她的恐惧并非凭空而来，激动、不安都是正常反应，让她知道不是自己独自承受，我会陪她面对，给她情绪支撑。


示例二
问题：孩子在山里走丢了，找了半天都没找到
我的性别：男性
我的年龄：中年
我的情感：担忧
回答情感：担忧
回复内容：孩子山里走失也太危险，你肯定急坏了，咱找村里人或警察一起找！
语音分析与回复：
语音中一个成年男性在说孩子在山里走失了，语气满是慌乱，山里危险，他因孩子安全紧张恐惧，情绪紧绷。中年男性作为家庭顶梁柱，对孩子安全极负责，走失会自责恐慌，此时需用急切担忧的语气共情，让他知道有人帮留意。

"""



def has_no_chinese(s):
    """
    判断字符串是否完全不含有中文

    参数:
        s: 待检查的字符串

    返回:
        True: 完全不含中文
        False: 含有中文
    """
    # 匹配中文的正则表达式（包括基本汉字和常见中文符号）
    chinese_pattern = re.compile(
        r'[\u4e00-\u9fa5\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]')
    # 检查是否有匹配的中文
    return not bool(chinese_pattern.search(s))


age_map = {
    "<CHILD>": "儿童",
    "<ADULT>": "成年人",
    "<OLD>": "老年人",
}
gender_map = {
    "<MALE>": "男性",
    "<FEMALE>": "女性",
}

# 生气 – ANGER
# 害怕 – FEAR
# 高兴 – HAPPY
# 惊讶 – SURPRISE
# 伤心 – SAD
# 厌恶 – DISGUST
# 疑惑 – CONFUSED
# 嘲讽 – SARCASM
# 尴尬 – EMBARRASSED
# 好奇 – CURIOUS
# 担忧/关心 – WORRIED
# 害羞 – SHY
# 抱歉 – SORRY
# 中性 – NEUTRAL
emotion_map = {
    "<ANGER>": "生气",
    "<FEAR>": "害怕",
    "<HAPPY>": "高兴",
    "<SURPRISE>": "惊讶",
    "<SAD>": "伤心",
    "<DISGUST>": "厌恶",
    "<CONFUSED>": "疑惑",
    "<SARCASM>": "嘲讽",
    "<EMBARRASSED>": "尴尬",
    "<CURIOUS>": "好奇",
    "<WORRIED>": "担忧/关心",
    "<SHY>": "害羞",
    "<SORRY>": "抱歉",
    "<NEUTRAL>": "中性",
"ANGER": "生气",
    "FEAR": "害怕",
    "HAPPY": "高兴",
    "SURPRISE": "惊讶",
    "SAD": "伤心",
    "DISGUST": "厌恶",
    "CONFUSED": "疑惑",
    "SARCASM": "嘲讽",
    "EMBARRASSED": "尴尬",
    "CURIOUS": "好奇",
    "WORRIED": "担忧/关心",
    "SHY": "害羞",
    "SORRY": "抱歉",
    "NEUTRAL": "中性",
}


def little_func(input_dict_list, valid_scp_path, exist_valid_dict=None):
    if exist_valid_dict is None:
        exist_valid_dict = {}
    dict_valid = {}
    for dict_i in tqdm(input_dict_list, total=len(input_dict_list)):
        try:
            key = dict_i['key']
            if key in exist_valid_dict:
                continue
            question_origin = dict_i['txt']
            question_origin = do_clean_text(question_origin)
            question_origin,_ = do_split_txt2asr_tag(question_origin)
            question = prompt_template.format(question_origin)
            answer = qwen3_vllm_chat(question)
            # print_info(f'{key}\t{question_origin}\t{answer}')
            dict_valid[key] = f'{question_origin}|{answer}'
        except Exception as e:
            print_info(f"error: {e}")
    write_dict_to_scp(dict_valid, valid_scp_path, 'a')

def little_func2(dict_list_little, output_data_path, exist_dict_keys_set=None):
    if exist_dict_keys_set is None:
        exist_dict_keys_set = set()
    index = 0
    # valid_dict_here = load_dict_from_scp(valid_scp_path)
    for dict_i in tqdm(dict_list_little, total=len(dict_list_little)):
        try:
            key = dict_i['key']
            extra_dict = dict_i['extra']
            question = extra_dict['q_txt']
            age_label = extra_dict.get('age', '<ADULT>')
            q_emotion = extra_dict.get('q_emotion', 'none')


            answer_str = dict_i['txt']
            if '>' in answer_str:
                a_emotion = answer_str.split(">")[0].strip()[1:]
                only_answer_str = answer_str.split(">")[1].strip()
            else:
                a_emotion = extra_dict.get('a_emotion', 'none')
                only_answer_str = answer_str

            gender_label = extra_dict.get('gender', 'none')
            if age_label == '<YOUTH>' or age_label == '<MIDDLE_AGE>':
                age_label = '<ADULT>'
            gender_label = gender_label.upper()
            extra_dict['age'] = age_label
            extra_dict['gender'] = gender_label
            # question_origin = do_clean_text(question)
            age_str = age_map.get(age_label, '未知')
            gender_str = gender_map.get(gender_label, '未知')
            q_emotion_str = emotion_map.get(q_emotion, '未知')
            a_emotion_str = emotion_map.get(a_emotion, '未知')
            if q_emotion_str == '未知':
                print_error(f"q_emotion: {q_emotion},有未知，跳过")
                continue
            if a_emotion_str == '未知':
                print_error(f"a_emotion: {a_emotion},有未知，跳过")
                continue
            full_answer_str = f'<{a_emotion_str}>{only_answer_str}'
            if age_str == '未知' or gender_str == '未知':
                print_error(f"age_str: {age_str}, gender_str: {gender_str},有未知，跳过")
                continue
            if ">" in question:
                question_for_tem = question.split(">")[-1]
            else:
                question_for_tem = question
            print_info(f'question:{question_for_tem}, gender_str:{gender_str}, age_str:{age_str}, q_emotion_str:{q_emotion_str}, a_emotion_str:{a_emotion_str}')
            if has_no_chinese(question):
                question_template = prompt_template2.format(question_for_tem, gender_str, age_str, q_emotion_str, a_emotion_str,)
            else:
                question_template = prompt_template2.format(question_for_tem, gender_str, age_str, q_emotion_str, a_emotion_str,)
            answer = qwen3_vllm_chat(question_template)
            if "<END>" not in answer:
                print_error(f"不是think格式，answer error: {answer}")
                continue
            if answer.endswith("<END>"):
                answer = answer[:-len("<END>")]
                answer = answer.strip()
            if "<END>" not in answer:
                print_error(f"不是think格式，answer error: {answer}")
                continue
            res_tmp = answer.split("<END>")
            if len(res_tmp) != 2:
                print_info(f"res_tmp: {res_tmp}")
            think_str = res_tmp[0]
            answer_str = res_tmp[-1]
            think_str = think_str.replace('\n', "")
            print_limit(f'-------------\n q:{question}\n t:{think_str}\n a:{answer_str}\n--------------')
            extra_dict['think_str'] = think_str
            dict_i['txt'] = full_answer_str
            dict_i['extra'] = extra_dict

            write_single_dict_to_jsonl(dict_i, output_data_path)
        except Exception as e:
            print_error(f"error: {e}")


def do_handle_for_age_gender(input_data_list, output_dir, ):
    # input_data_list = "/home/A02_tmpdata3/osum_s2s/gender/data.list"
    # work_dir = "/home/A02_tmpdata3/osum_s2s/gender/s2s_handle_part1"
    work_dir = output_dir
    # valid_scp_path = f'{work_dir}/valid.scp'
    # if os.path.exists(valid_scp_path):
    #     exist_valid_dict = load_dict_from_scp(valid_scp_path)
    # else:
    #     exist_valid_dict = {}
    # makedirs(work_dir)
    dict_list = load_dict_list_from_jsonl(input_data_list)
    # num_thread = 100
    # dict_list_split = do_split_list(dict_list, num_thread)
    # runner = DragonDynamicProcessPool()
    # for dict_list_i in dict_list_split:
    #     runner.apply_async(little_func, [dict_list_i,valid_scp_path ,exist_valid_dict])
    # runner.run()
    # print_info('句子可行性验证完毕。。。。。。。。。。。。。。。。。。。开始制造回答')

    output_data_list_path = f'{work_dir}/data_s2s.list'
    exist_dict_keys_set = set()
    if os.path.exists(output_data_list_path):
        exist_dict_list = load_dict_list_from_jsonl(output_data_list_path)
        for dict_i in exist_dict_list:
            exist_dict_keys_set.add(dict_i['key'])
    runner2 = DragonDynamicProcessPool()
    thread_num = 100
    dict_list_split2 = do_split_list(dict_list, thread_num)
    for dict_list_i in dict_list_split2:
        runner2.apply_async(little_func2, [dict_list_i, output_data_list_path ,exist_dict_keys_set])
    runner2.run()
    print_info(f"完全处理完成")

def get_part2():
    # 得到gender for part2 的data.list
    input_dict_path = "/home/A02_tmpdata3/osum_s2s/gender/data.list"
    dict_list = load_dict_list_from_jsonl(input_dict_path)
    valid_part1_path = "/home/A02_tmpdata3/osum_s2s/gender/s2s_handle_part1/valid.scp"
    valid_dict = load_dict_from_scp(valid_part1_path)
    new_dict_list = []
    for dict_i in tqdm(dict_list):
        key = dict_i['key']
        if key in valid_dict:
            continue
        new_dict_list.append(dict_i)
    output_data_path = "/home/A02_tmpdata3/osum_s2s/gender/data4part2.list"
    write_dict_list_to_jsonl(new_dict_list, output_data_path)

def do_simple_valid_dict():
    valid_dict_path = "/home/A02_tmpdata3/osum_s2s/gender/s2s_handle_part2/valid.scp"
    valid_dict = load_dict_from_scp(valid_dict_path)
    write_dict_to_scp(valid_dict, "/home/A02_tmpdata3/osum_s2s/gender/s2s_handle_part2/valid.scp")

def do_get_part1():
    all_dict_path = "/home/A02_tmpdata3/osum_s2s/gender/data.list"
    part2_dict_path = "/home/A02_tmpdata3/osum_s2s/gender/data4part2.list"
    all_dict_list = load_dict_list_from_jsonl(all_dict_path)
    part2_dict_list = load_dict_list_from_jsonl(part2_dict_path)
    part2_key_sets = set()
    for dict_i in tqdm(part2_dict_list):
        part2_key_sets.add(dict_i['key'])
    new_dict_list = []
    for dict_i in tqdm(all_dict_list):
        key = dict_i['key']
        if key in part2_key_sets:
            continue
        new_dict_list.append(dict_i)
    output_data_path = "/home/A02_tmpdata3/osum_s2s/gender/data4part1.list"
    write_dict_list_to_jsonl(new_dict_list, output_data_path)


def do_test_for_little():
    input_data_list = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/handle_data/data_little.list"
    dict_list_little = load_dict_list_from_jsonl(input_data_list)
    for dict_i in tqdm(dict_list_little, total=len(dict_list_little)):
        try:
            key = dict_i['key']
            question = dict_i['txt']
            extra_dict = dict_i['extra']
            age_label = extra_dict.get('age', 'none')
            q_emotion = extra_dict.get('q_emotion', 'none')
            gender_label = extra_dict.get('gender', 'none')
            if age_label == '<YOUTH>' or age_label == '<MIDDLE_AGE>':
                age_label = '<ADULT>'
            gender_label = gender_label.upper()
            extra_dict['age'] = age_label
            extra_dict['gender'] = gender_label
            question_origin = do_clean_text(question)
            age_str = age_map.get(age_label, '未知')
            gender_str = gender_map.get(gender_label, '未知')
            q_emotion_str = emotion_map.get(q_emotion, '未知')
            if q_emotion_str == '未知':
                print_error(f"q_emotion: {q_emotion},有未知，跳过")
                continue
            if age_str == '未知' or gender_str == '未知':
                print_error(f"age_str: {age_str}, gender_str: {gender_str},有未知，跳过")
                continue
            if has_no_chinese(question_origin):
                question = prompt_template2.format(question_origin, gender_str, age_str, q_emotion_str)
            else:
                question = prompt_template2.format(question_origin, gender_str, age_str, q_emotion_str)
            answer = qwen3_vllm_chat(question)
            if "<END>" not in answer:
                print_error(f"不是think格式，answer error: {answer}")
                continue
            if answer.endswith("<END>"):
                answer = answer[:-len("<END>")]
                answer = answer.strip()
            if "<END>" not in answer:
                print_error(f"不是think格式，answer error: {answer}")
                continue
            res_tmp = answer.split("<END>")
            if len(res_tmp) != 2:
                print_info(f"res_tmp: {res_tmp}")
            think_str = res_tmp[0]
            answer_str = res_tmp[-1]
            print_info(f'q:{question_origin}: t:{think_str}, a:{answer_str}')
        except Exception as e:
            print_error(f"error: {e}")

def do_qu_chong():
    input_path = "/home/A02_tmpdata3/osum_s2s/gender/s2s_handle_part2/data_s2s.list"
    output_path = "/home/A02_tmpdata3/osum_s2s/gender/s2s_handle_part2/data_s2s_qu_chong.list"
    dict_list = load_dict_list_from_jsonl(input_path)
    new_dict_list = []
    keys_set = set()
    for dict_i in tqdm(dict_list):
        key = dict_i['key']
        if key in keys_set:
            continue
        keys_set.add(key)
        new_dict_list.append(dict_i)
    write_dict_list_to_jsonl(new_dict_list, output_path)

def convert_datalist2scp():
    input_data_list_path = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/raw_data/data.list"
    output_wav_scp_path = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/raw_data/wav.scp"
    dict_list = load_dict_list_from_jsonl(input_data_list_path)
    new_list = []
    for dict_i in dict_list:
        wav_path = dict_i['wav']
        new_list.append(wav_path)
    write_list_to_file(new_list, output_wav_scp_path)

def do_add_gender_info_2_datalist():
    """"""
    data_list_path = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/raw_data/data.list"
    gender_scp = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/raw_data/gender.txt"
    gender_dict = load_dict_from_scp(gender_scp)
    new_gender_dict = {}
    for key, value in gender_dict.items():
        items = value.split()
        gender = items[1]
        gender_tag = "<" + gender.upper() + ">"
        new_gender_dict[key] = gender_tag
    data_list = load_dict_list_from_jsonl(data_list_path)
    new_data_list = []
    new_data_list_path = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/handle_data/data_only_q.list"
    for dict_i in tqdm(data_list):
        key = dict_i['key']
        file_path_key = dict_i['file_path_key']
        q_wav_path = dict_i['wav']
        if key in new_gender_dict:
            try:
                gender_tag = new_gender_dict[key]
                question_txt = dict_i['extra_dict']["q_txt"]
                q_emotion = dict_i['extra_dict'].get("q_emotion", None)
                if q_emotion is None:
                    answer_txt = dict_i['txt']
                    emotion_tag, _ = do_split_txt2tag_str(answer_txt)
                    # if emotion_tag == "<SURPRISE>":
                    q_emotion = emotion_tag
                    # else:
                    #     raise ValueError(f"emotion_tag: {emotion_tag} not in q_emotion_set")
                new_dict = dict(
                    key=key,
                    wav=q_wav_path,
                    txt=question_txt,
                    file_path_key=file_path_key,
                    extra={
                        "gender": gender_tag,
                        "age": "<ADULT>",
                        "q_emotion": q_emotion,
                    }
                )
                new_data_list.append(new_dict)
            except Exception as e:
                print_error(f"error: {e}, dict_i: {dict_i}")
                continue
        else:
            print_error(f"key: {key} not in gender_dict")
    write_dict_list_to_jsonl(new_data_list, new_data_list_path)

def do_data_tongji():
    input_data_list_path = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/handle_data/data_only_q.list"
    data_list = load_dict_list_from_jsonl(input_data_list_path)
    q_emotion_dict = {}
    for dict_i in data_list:
        q_emotion = dict_i['extra']['q_emotion']
        if q_emotion not in q_emotion_dict:
            q_emotion_dict[q_emotion] = {'male': 0, 'female': 0, 'total': 0}
        gender = dict_i['extra']['gender']
        if gender == "<MALE>":
            q_emotion_dict[q_emotion]['male'] += 1
        elif gender == "<FEMALE>":
            q_emotion_dict[q_emotion]['female'] += 1
        else:
            print_error(f"gender: {gender} not in <MALE> or <FEMALE>")
        q_emotion_dict[q_emotion]['total'] += 1
    print_info(f"q_emotion_dict: {q_emotion_dict}")
    write_dict_to_json(q_emotion_dict, "./q_emotion_dict.json")


def do_make_tar_for_emotion30K():
    input_data_list_path = "/home/A02_tmpdata3/emotion/中英混多音色情感数据库/s2s_handle/data_s2s.list"
    output_dir = "/home/A02_tmpdata3/emotion/中英混多音色情感数据库/s2s_handle/shards"
    do_replace_str_to_file('"question":', '"q_txt":', input_data_list_path, input_data_list_path)
    do_make_shards_common(input_data_list_path, output_dir)


def do_make_think_for_raw_data():
    input_data_list_path = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/handle_data/s2s_handle/xlgeng_new_data/emotion_data_raw/data_no_child_no_osum.list"
    output_dir = "/home/A02_tmpdata3/osum_s2s/emotion_yinshi_zxzhao_with_q_emo_by_cywang_added_by_20250701/handle_data/s2s_handle/xlgeng_new_data/emotion_data_raw/with_think"
    makedirs(output_dir)
    do_handle_for_age_gender(
        input_data_list=input_data_list_path,
        output_dir=output_dir,
    )
    # dict_list = load_dict_list_from_jsonl(input_data_list_path)
    # little_dict_list = dict_list[:10]
    # little_func2(little_dict_list, output_dir+'/data_s2s_little.list')



if __name__ == '__main__':
    """"""
    # do_test_for_little()
    # do_simple_valid_dict()
    # do_get_part1()
    # do_qu_chong()
    # convert_datalist2scp()
    # do_add_gender_info_2_datalist()
    # do_data_tongji()
    # do_test_for_little()
    # do_make_tar_for_emotion30K()
    # do_handle_for_age_gender(
    #     input_data_list="/home/A02_tmpdata3/emotion/中英混多音色情感数据库/merged_data.jsonl",
    #     output_dir="/home/A02_tmpdata3/emotion/中英混多音色情感数据库/s2s_handle"
    # )
    do_make_think_for_raw_data()
    # little_func2()
    # print_info(has_no_chinese('ahaha'))

    # do_test4age_gender(
    #     input_data_list="/home/A02_tmpdata3/osum_s2s/gender_add_2025_2_4_fix/data.list",
    #     output_dir="/home/A02_tmpdata3/osum_s2s/gender_add_2025_2_4_fix/s2s_handle_part1",
    #     qwen3_ip = "10.21.4.3"
    # )
    #
    # do_test4age_gender(
    #     input_data_list="/home/A02_tmpdata3/osum_s2s/gender_with_noize_add_2025_2_4/data.list",
    #     output_dir="/home/A02_tmpdata3/osum_s2s/gender_with_noize_add_2025_2_4/s2s_handle_part1"
    # )
    #
    # do_test4age_gender(
    #     input_data_list="/home/A02_tmpdata3/osum_s2s/age_3000_noize/data.list",
    #     output_dir="/home/A02_tmpdata3/osum_s2s/age_3000_noize/s2s_handle_part1"
    # )
    #
    # do_test4age_gender(
    #     input_data_list="/home/A02_tmpdata3/osum_s2s/gender/data.list",
    #     output_dir="/home/A02_tmpdata3/osum_s2s/gender/s2s_handle_part2"
    # )


